// 字符串相关
let url = 'http://www.domain.com/?user=anonymous&id=123&id=456&city=%E5%8C%97%E4%BA%AC&enabled';
// 解析 URL Params 为对象
function parseParam1(url) {
    const paramsStr = /.+\?(.+)$/.exec(url)[1]; // 将 ? 后面的字符串取出来
    const paramsArr = paramsStr.split('&'); // 将字符串以 & 分割后存到数组中
    let paramsObj = {};
    // 将 params 存到对象中
    paramsArr.forEach(param => {
      if (/=/.test(param)) { // 处理有 value 的参数
        let [key, val] = param.split('='); // 分割 key 和 value
        val = decodeURIComponent(val); // 解码
        val = /^\d+$/.test(val) ? parseFloat(val) : val; // 判断是否转为数字
  
        if (paramsObj.hasOwnProperty(key)) { // 如果对象有 key，则添加一个值
          paramsObj[key] = [].concat(paramsObj[key], val);
        } else { // 如果对象没有这个 key，创建 key 并设置值
          paramsObj[key] = val;
        }
      } else { // 处理没有 value 的参数
        paramsObj[param] = true;
      }
    })
    return paramsObj;
  }
// 模板引擎实现
let template = '我是{{name}}，年龄{{age}}，性别{{sex}}';
let data = {
    name: '姓名',
    age: 18
  }
// console.log(render(template,data));
function render(template, data) {
    let reg = /\{\{(\w+)\}\}/
    if (reg.test(template)) {
        let temp = reg.exec(template)[1];
        template = template.replace(reg,data[temp])
        return render(template,data)
    }
    return template;
}
// 转化为驼峰命名
var s1 = "get-element-by-id"
// console.log(changeUpper(s1));
function changeUpper(s) {
    let reg = /-\w/g
   return s.replace(reg,(x)=>{
       return  x.slice(1).toUpperCase()
    })
}
// 查找字符串中出现最多的字符和个数
// 例: abbcccddddd -> 字符最多的是d，出现了5次
// findStrMore('abbcccddddd')
function findStrMore(str){
    let strObj = {}
    for (let i = 0; i < str.length; i++) {
       if (strObj.hasOwnProperty(str[i])) {
            strObj[str[i]] = strObj[str[i]]+1
       }else{
            strObj[str[i]] = 1
       }
    }
    let max = 0;
    let maxKey = 0
    for (const key in strObj) {
        if (strObj[key] > max) {
            max = strObj[key];
            maxKey = key;
        }
    }
    console.log('---字符串最大的是'+maxKey,'出现了'+max+'次');
}
// 找出字符串中连续出现最多的字符和个数
// let str = "abcabcabbbbbbbcbbcccccb";
// findLianxu(str)
function findLianxu(str){
    let i = 0
    let j = 0;
    let arr = []
    while (j <= str.length) {
        if (str[i] == str[j]) {
            j++
        }else{
            arr.push(str.slice(i,j))
            i = j;
        }
    }
    let maxNum = 0;
    let key = null;
    for (const item of arr) {
        if (item.length > maxNum) {
            maxNum = item.length
            key = item[0]
        }
    }
    console.log(arr);
    console.log('---连续出现最多的字符是'+key,'出现了'+maxNum+'次');
}
// 字符串查找
// 请使用最基本的遍历来实现判断字符串 a 是否被包含在字符串 b 中，并返回第一次出现的位置
// a='34';b='1234567'; // 返回 2
function findContainer1(a,b){
    for (let i = 0; i < b.length; i++) {
        if (b[i] == a[0]) {
            if (i+a.length <= b.length) {
                let temp = b.slice(i,i+a.length);
                if (temp == a) {
                    return i
                }
            }
        }
    }
    return -1
}
function findContainer(a,b){
    if (a.length > b.length) return -1
    let i = 0
    while (i < b.length) {
        if (b[i] == a[0]) {
            let j = 0
            while (j < a.length && i+j < b.length) {
                if (b[i+j] && b[i+j] == a[j]) {
                    j++;
                }else{
                    break;
                }
            }
            if (b.slice(i,j+i) === a) {
                return i;
            }
        }
        i++;
    }
    return -1
}
// console.log(findContainer1('34','12355346735'));
// console.log(findContainer('34','12355346735'));
// 实现千位分隔符
// console.log(parseToMoney(1232324.56)); // return '1,234.56'
function parseToMoney1(num){
    if (typeof num !== 'number' || isNaN(num)) return num
    let partArr = num.toString().split('.');
    let part1 = '';
    let part2 = '';
    if (partArr.length > 1) {
        part1 = partArr[0];
        part2 = partArr[1];
    }else{
        part2 = '00'
    }
    let offSet = 3;
    let i = part1.length
    let partDart = []
    while (offSet < i) {
        i = i - offSet;
        partDart.unshift(part1.substr(i,3))
    } 
    if (i != 0) {
        partDart.unshift(part1.substr(0,i))
    }
    let result = partDart.join(',') + '.' + part2
    return result
}
function parseToMoney(num) {
    num = parseFloat(num.toFixed(3));
    let [integer, decimal] = String.prototype.split.call(num, '.');
    integer = integer.replace(/\d(?=(\d{3})+$)/g, ' $&,');//$&表示匹配的字符串  匹配出来的是\d ?=表示匹配的表达式后面的内容 这里就是 一个数字后面要有三个数字这个正则才成立
    return integer + '.' + (decimal ? decimal : '');
  }
// 电话号码验证
function isPhone(str){
    let reg = /^1[34578]\d{9}$/
    return reg.test(str)
}
// 邮箱验证
function isEmail(email) {
    var regx = /^([a-zA-Z0-9_\-])+@([a-zA-Z0-9_\-])+(\.[a-zA-Z0-9_\-])+$/;
    return regx.test(email);
}
// 无重复字符的最长子串
// abcabcbb
// console.log(lengthOfLongestSubstring('abcabcbb'))
function lengthOfLongestSubstring (s){
    let left = 0;
    let res = 0;
    let map = new Map()//存放字符和对应的下标  
    for (let right = 0; right < s.length; right++) { 
       if (map.has(s[right]) && map.get(s[right]) >= left) { //map中已经有这个字符了 注意同时满足重复字符的索引大于左指针。 左指针之前的都是不要的
            // 这个地方不太好理解 重点解释一下 比如 ab123456789cdefgc 碰到了第二个c，那么这里就没必要在从b走了，因为这里走后碰到第二个c后的长度肯定比第一次的小
            // 所以可以直接跳到第一个c后面继续进行
           left = map.get(s[right]) + 1;//左指针要移动到这个重复字符的下一位  相当于把前面的重复字符删除
       }
       res = Math.max(res,right-left+1)
       map.set(s[right],right);    //设置字符和下标
    }
	return res
}

// 使用JS将手机号进行加密中间四位变成*号
let phone = 15834563675
// 正则
function phoneJiaMi(str){
    str = str.toString()
    let reg = /(\d{3})\d{4}(\d{4})/g;
   return str.replace(reg,'$1****$2')
}
// console.log(phoneJiaMi1(phone));
// 分割
function phoneJiaMi1(str){
    str = str.toString()
    let str1 = str.slice(0,3);
    let str2 = str.slice(str.length-4);
    return str1+'****'+str2
}
// 判断一个字符串是不是回文字符串
// "A man, a plan, a canal: Panama"
function isHuiWen(str){
    str = str.toUpperCase();
    let arr = [];
    i = 0
    while (i < str.length) {
        if (/[a-zA-Z0-9]/.test(str[i]) ) {
            arr.push(str[i])
        }
        i++
    }
    var str1 = arr.join('');
    var str2 = arr.reverse().join('');
    return str1===str2;
}
console.log(palindromeStrLong("A man, a plan, a canal: Panama"));
function isPalindrome(str){
    let str1 = str.split('').reverse().join('');
    return str1 == str
}
// 判断字符串中的所有回文字符串
function palindromeStr(str) {
    var temp = '';
    var result=[];
    let arr = [];
    let index = 0;
    //只验证数字和字母
    while (index < str.length) {
        if (/[a-zA-Z0-9]/.test(str[index]) ) {
            arr.push(str[index])
        }
        index++
    }
    str = arr.join('');
    for(let i=0;i<str.length;i++){
        temp = '';
        for(var j=i;j<str.length;j++){
            temp+=str.charAt(j);
            if(isPalindrome(temp) && result.indexOf(temp) == -1){
                result.push(temp);
            }
        }
    }
    return result;
}
// 找到最长的回文字符串
function palindromeStrLong(str){
   let result =  palindromeStr(str);
   let maxLen = 0;
   let keyLen = 0;
   console.log(result);
   for (const key in result) {
       if (result[key].length > maxLen) {
            keyLen = key
            maxLen = result[key].length
       }
   }
   return result[keyLen]
}


javascript


  